home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / pgp20src.zip / KEYMGMT.C < prev    next >
C/C++ Source or Header  |  1992-09-03  |  68KB  |  2,220 lines
  1. /*    keymgmt.c  - Key management routines for PGP.
  2.     PGP: Pretty Good(tm) Privacy - public key cryptography for the masses.
  3.  
  4.     (c) Copyright 1990-1992 by Philip Zimmermann.  All rights reserved.
  5.     The author assumes no liability for damages resulting from the use
  6.     of this software, even if the damage results from defects in this
  7.     software.  No warranty is expressed or implied.
  8.  
  9.     All the source code Philip Zimmermann wrote for PGP is available for
  10.     free under the "Copyleft" General Public License from the Free
  11.     Software Foundation.  A copy of that license agreement is included in
  12.     the source release package of PGP.  Code developed by others for PGP
  13.     is also freely available.  Other code that has been incorporated into
  14.     PGP from other sources was either originally published in the public
  15.     domain or was used with permission from the various authors.  See the
  16.     PGP User's Guide for more complete information about licensing,
  17.     patent restrictions on certain algorithms, trademarks, copyrights,
  18.     and export controls.  
  19. */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #ifdef UNIX
  24. #include <sys/types.h>
  25. #endif
  26. #include <time.h>
  27. #include <ctype.h>
  28. #include "mpilib.h"
  29. #include "idea.h"
  30. #include "random.h"
  31. #include "crypto.h"
  32. #include "fileio.h"
  33. #include "keymgmt.h"
  34. #include "genprime.h"
  35. #include "rsagen.h"
  36. #include "mpiio.h"
  37. #include "language.h"
  38. #include "pgp.h"
  39.  
  40.  
  41. /*
  42. **    Convert to or from external byte order.
  43. **    Note that convert_byteorder does nothing if the external byteorder
  44. **  is the same as the internal byteorder.
  45. */
  46. #define convert2(x,lx)    convert_byteorder( (byteptr)&(x), (lx) )
  47. #define convert(x)        convert2( (x), sizeof(x) )
  48.  
  49.  
  50. /*
  51.  * check if userid matches the substring, magic characters ^ and $
  52.  * can be used to match start and end of userid.
  53.  * the comparison is case insensitive
  54.  */
  55. boolean userid_match(char *userid, char *substr)
  56. {
  57.     boolean match_end = FALSE;
  58.     int id_len, sub_len, i;
  59.     char buf[256], sub[256], *p;
  60.  
  61.     if (substr == NULL || *substr == '\0')
  62.         return(TRUE);
  63.     if (userid == NULL || *userid == '\0')
  64.         return(FALSE);
  65.  
  66.     id_len = strlen(userid);
  67.     for (i = 0; i <= id_len; ++i)
  68.         buf[i] = tolower(userid[i]);
  69.  
  70.     sub_len = strlen(substr);
  71.     for (i = 0; i <= sub_len; ++i)
  72.         sub[i] = tolower(substr[i]);
  73.  
  74. #ifdef MAGIC_MATCH
  75.     if (sub_len > 1 && sub[sub_len - 1] == '$')
  76.     {
  77.         match_end = TRUE;
  78.         sub[--sub_len] = '\0';
  79.     }
  80.     if (*sub == '^')
  81.     {    if (match_end)
  82.             return(!strcmp(buf, sub + 1));
  83.         else
  84.             return(!strncmp(buf, sub + 1, sub_len - 1));
  85.     }
  86. #endif
  87.     if (sub_len > id_len)
  88.         return(FALSE);
  89.  
  90.     if (match_end)
  91.         return(!strcmp(buf + id_len - sub_len, sub));
  92.  
  93.     p = buf;
  94.     while ((p = strchr(p, *sub)) != NULL)
  95.     {
  96.         if (strncmp(p, sub, sub_len) == 0)
  97.             return(TRUE);
  98.         ++p;
  99.     }
  100.     return(FALSE);
  101. }
  102.  
  103. int
  104. is_key_ctb (byte ctb)
  105. {
  106.     return(ctb == CTB_CERT_PUBKEY  ||  ctb == CTB_CERT_SECKEY);
  107. }
  108.  
  109.  
  110. char *keyIDstring(byte *keyID)
  111. /*    Return printable key fragment, which is an abbreviation of 
  112.     the public key.
  113.     Show LEAST significant 64 bits (KEYFRAGSIZE bytes) of modulus,
  114.     LSB last.  Yes, that's LSB LAST.
  115. */
  116. {    short i,j;
  117.     static char keyIDbuf[2*KEYFRAGSIZE+1];
  118.     char *bufptr;    /* ptr to Key ID string */
  119.     bufptr = keyIDbuf;
  120.     fill0(bufptr,sizeof(keyIDbuf));
  121. #ifdef XLOWFIRST    /* LSB-first keyID format */
  122.     j = KEYFRAGSIZE;
  123.     for (i=KEYFRAGSIZE-1; i>=0; i--)    /* print LSB last */
  124.     {    if (--j < 3)    /* only show bottom 3 bytes of keyID */
  125.         {    sprintf(bufptr,"%02X",keyID[i]);
  126.             bufptr += 2;
  127.         }
  128.         *bufptr = 0;
  129.     }
  130. #else        /* MSB-first keyID format */
  131.     j = KEYFRAGSIZE;
  132.     for (i=0; i<KEYFRAGSIZE; i++)    /* print LSB last */
  133.     {    if (--j < 3)    /* only show bottom 3 bytes of keyID */
  134.         {    sprintf(bufptr,"%02X",keyID[i]);
  135.             bufptr += 2;
  136.         }
  137.         *bufptr = 0;
  138.     }
  139. #endif
  140.     return(keyIDbuf);
  141. }    /* keyIDstring */
  142.  
  143.  
  144.  
  145. void extract_keyID(byteptr keyID, unitptr n)
  146. /*    Extract key fragment from modulus n.  keyID byte array must be
  147.     at least KEYFRAGSIZE bytes long.
  148. */
  149. {    byte buf[MAX_BYTE_PRECISION+2];
  150.     short i, j;
  151.  
  152.     fill0(buf,KEYFRAGSIZE+2); /* in case n is too short */
  153.     reg2mpi(buf,n);    /* MUST be at least KEYFRAGSIZE long */
  154. #ifdef XLOWFIRST
  155.     i = reg2mpi(buf,n);    /* MUST be at least KEYFRAGSIZE long */
  156.     /* For LSB-first keyID format, start of keyID is: */
  157.     i = 2;    /* skip over the 2 bytes of bitcount */
  158.     for (j=0; j<KEYFRAGSIZE; )
  159.         keyID[j++] = buf[i++];
  160. #else
  161.     i = reg2mpi(buf,n);    /* MUST be at least KEYFRAGSIZE long */
  162.     /* For MSB-first keyID format, start of keyID is: */
  163.     i = i + 2 - KEYFRAGSIZE;
  164.     for (j=0; j<KEYFRAGSIZE; )
  165.         keyID[j++] = buf[i++];
  166. #endif
  167.  
  168. }    /* extract_keyID */
  169.  
  170.  
  171.  
  172. char *key2IDstring(unitptr n)
  173. /*    Derive the key abbreviation fragment from the modulus n, 
  174.     and return printable string of key ID.
  175.     n is key modulus from which to extract keyID.
  176. */
  177. {    byte keyID[KEYFRAGSIZE];
  178.     extract_keyID(keyID, n);
  179.     return (keyIDstring(keyID));
  180. }    /* key2IDstring */
  181.  
  182.  
  183.  
  184. void showkeyID(byteptr keyID)
  185. /*    Print key fragment, which is an abbreviation of the public key. */
  186. {
  187.     fprintf(pgpout,"%s",keyIDstring(keyID));
  188. }    /* showkeyID */
  189.  
  190.  
  191.  
  192. void writekeyID(unitptr n, FILE *f)
  193. /*    Write message prefix keyID to a file.
  194.     n is key modulus from which to extract keyID.
  195. */
  196. {    byte keyID[KEYFRAGSIZE];
  197.     extract_keyID(keyID, n);
  198.     fwrite(keyID,1,KEYFRAGSIZE,f);
  199. }    /* writekeyID */
  200.  
  201.  
  202.  
  203. boolean checkkeyID(byte *keyID, unitptr n)
  204. /*    Compare specified keyID with one derived from actual key modulus n. */
  205. {
  206.     byte keyID0[KEYFRAGSIZE];
  207.     if (keyID==NULL) /* no key ID -- assume a good match */
  208.         return (TRUE);
  209.     extract_keyID(keyID0, n);
  210.     return(equal_buffers(keyID,keyID0,KEYFRAGSIZE));
  211. }    /* checkkeyID */
  212.  
  213.  
  214.  
  215. /* external function prototype, from mpiio.c */
  216. void dump_unit_array(string s, unitptr r);
  217.  
  218. void write_trust (FILE *f, byte trustbyte)
  219. /*    Write a key control packet to f, with the specified trustbyte data.
  220.  */
  221. {
  222.     byte ctb;
  223.     byte keyctrllen;
  224.  
  225.     ctb = CTB_KEYCTRL;
  226.     fwrite(&ctb,1,1,f);        /* write key control header byte */
  227.     keyctrllen = 1;
  228.     fwrite(&keyctrllen,1,1,f);    /* write key control length */
  229.     fwrite(&trustbyte,1,1,f);    /* write key control */
  230. }
  231.  
  232. short writekeyfile(char *fname, boolean hidekey, byte *timestamp, byte *userid, 
  233.     unitptr n, unitptr e, unitptr d, unitptr p, unitptr q, unitptr u)
  234. /*    Write key components p, q, n, e, d, and u to specified file.
  235.     hidekey is TRUE iff key should be encrypted.
  236.     userid is a length-prefixed Pascal-type character string. 
  237.     We write three packets: a key packet, a key control packet, and
  238.     a userid packet.  We assume the key being written is our own,
  239.     so we set the control bits for full trust.
  240. */
  241. {    FILE *f;
  242.     byte ctb;
  243.     byte alg, version;
  244.     word16 validity;
  245.     word16 cert_length;
  246.     extern word16 mpi_checksum;
  247.     byte iv[8];
  248.     int i;
  249.  
  250.     /* open file f for write, in binary (not text) mode...*/
  251.     if ((f = fopen(fname,"wb")) == NULL)
  252.     {    fprintf(pgpout,PSTR("\n\007Unable to create key file '%s'.\n"), fname);
  253.         return(-1);
  254.     }
  255.     /*** Begin key certificate header fields ***/
  256.     if (d==NULL)
  257.     {    /* public key certificate */
  258.         ctb = CTB_CERT_PUBKEY;
  259.         cert_length = 1 + SIZEOF_TIMESTAMP + 2 + 1 + (countbytes(n)+2)
  260.             + (countbytes(e)+2);
  261.     }    /* public key certificate */
  262.     else
  263.     {    /* secret key certificate */
  264.         ctb = CTB_CERT_SECKEY;
  265.             cert_length = 1 + SIZEOF_TIMESTAMP + 2 + 1
  266.             + (countbytes(n)+2)
  267.             + (countbytes(e)+2)
  268.             + 1 + (hidekey ? 8 : 0)        /* IDEA algorithm byte and IV */
  269.             + (countbytes(d)+2)
  270.             + (countbytes(p)+2)    + (countbytes(q)+2) 
  271.             + (countbytes(u)+2) + 2;
  272.  
  273.     }    /* secret key certificate */
  274.  
  275.     fwrite(&ctb,1,1,f);        /* write key certificate header byte */
  276.     convert(cert_length);    /* convert to external byteorder */
  277.     fwrite(&cert_length,1,sizeof(cert_length),f);
  278.     version = VERSION_BYTE;
  279.     fwrite(&version,1,1,f);        /* set version number */
  280.     convert_byteorder(timestamp,4);    /* convert to external form */
  281.     fwrite(timestamp,1,4,f); /* write certificate timestamp */
  282.     convert_byteorder(timestamp,4);    /* convert back to internal form */
  283.     validity = 0;
  284.     fwrite (&validity,1,sizeof(validity),f);    /* validity period */
  285.     alg = RSA_ALGORITHM_BYTE;
  286.     fwrite(&alg,1,1,f);
  287.     write_mpi(n,f,FALSE);
  288.     write_mpi(e,f,FALSE);
  289.  
  290.     if (is_secret_key(ctb))    /* secret key */
  291.     {
  292.         /* Write byte for following algorithm */
  293.         alg = (hidekey)?IDEA_ALGORITHM_BYTE:0;
  294.         fwrite(&alg,1,1,f);
  295.  
  296.         if (hidekey)  /* store encrypted IV */
  297.         {    for (i=0; i<8; i++)
  298.                 iv[i] = randombyte();
  299.             if (hidekey)  /* encrypt the IV */
  300.                 ideacfb(iv,8);
  301.             fwrite(iv,1,8,f);    /* write out the IV */
  302.         }
  303.         mpi_checksum = 0;
  304.         write_mpi(d,f,hidekey);
  305.         write_mpi(p,f,hidekey);
  306.         write_mpi(q,f,hidekey);
  307.         write_mpi(u,f,hidekey);
  308.         /* Write checksum here - based on plaintext values */
  309.         convert(mpi_checksum);
  310.         fwrite (&mpi_checksum,1,sizeof(mpi_checksum),f);
  311.     } else {
  312.         /* Keyring control packet, public keys only */
  313.         write_trust (f, KC_OWNERTRUST_ULTIMATE | KC_BUCKSTOP);
  314.     }
  315.     /* User ID packet */
  316.     ctb = CTB_USERID;
  317.     fwrite(&ctb,1,1,f);        /* write userid header byte */
  318.     fwrite(userid,1,userid[0]+1,f);    /* write user ID */
  319.     if (d == NULL)    /* only on public keyring */
  320.         write_trust (f, KC_LEGIT_COMPLETE);
  321.     fclose(f);
  322. #ifdef DEBUG
  323.     fprintf(pgpout,"\n%d-bit %s key written to file '%s'.\n",
  324.         countbits(n),
  325.         is_secret_key(ctb) ? "secret" : "public" ,
  326.         fname);
  327. #endif
  328.     return(0);
  329. }    /* writekeyfile */
  330.  
  331.  
  332.  
  333. /* Return -1 on EOF, else read next key packet, return its ctb, and
  334.  * advance pointer to beyond the packet.
  335.  * This is short of a "short form" of readkeypacket
  336.  */
  337. short nextkeypacket(FILE *f, byte *pctb)
  338. {
  339.     word32 cert_length;
  340.     int count;
  341.     byte ctb;
  342.  
  343.     *pctb = 0;    /* assume no ctb for caller at first */
  344.     count = fread(&ctb,1,1,f);    /* read key certificate CTB byte */
  345.     if (count==0) return(-1);    /* premature eof */
  346.     *pctb = ctb;    /* returns type to caller */
  347.     if ((ctb != CTB_CERT_PUBKEY) && (ctb != CTB_CERT_SECKEY)  &&
  348.             (ctb != CTB_USERID)  &&  (ctb != CTB_KEYCTRL)  &&
  349.             !is_ctb_type(ctb,CTB_SKE_TYPE) &&
  350.             !is_ctb_type(ctb,CTB_COMMENT_TYPE))
  351.         /* Either bad key packet or X/Ymodem padding detected */
  352.         return ((ctb == 0x1A) ? -1 : -2);
  353.  
  354.     cert_length = getpastlength(ctb, f); /* read certificate length */
  355.  
  356.     if (cert_length > MAX_KEYCERT_LENGTH-3)
  357.         return(-3);    /* bad length */
  358.  
  359.     fseek(f, cert_length, SEEK_CUR);
  360.     return(0);
  361. } /* nextkeypacket */
  362.  
  363.  
  364. short readkeypacket(FILE *f, boolean hidekey, byte *pctb,
  365.     byte *timestamp, char *userid,
  366.     unitptr n ,unitptr e, unitptr d, unitptr p, unitptr q, unitptr u,
  367.     byte *sigkeyID, byte *keyctrl)
  368. /*    Reads a key certificate from the current file position of file f.
  369.     Depending on the certificate type, it will set the proper fields
  370.     of the return arguments.  Other fields will not be set.
  371.     pctb is always set.
  372.     If the packet is CTB_CERT_PUBKEY or CTB_CERT_SECKEY, it will
  373.     return timestamp, n, e, and if the secret key components are
  374.     present and d is not NULL, it will read, decrypt if hidekey is
  375.     true, and return d, p, q, and u.
  376.     If the packet is CTB_KEYCTRL, it will return keyctrl as that byte.
  377.     If the packet is CTB_USERID, it will return userid.
  378.     If the packet is CTB_COMMENT_TYPE, it won't return anything extra.
  379.     The file pointer is left positioned after the certificate.
  380. */
  381. {
  382.     byte ctb;
  383.     word16 cert_length;
  384.     int count;
  385.     byte version, alg, mdlen;
  386.     word16 validity;
  387.     word16 chksum;
  388.     extern word16 mpi_checksum;
  389.     byte iv[8];
  390.  
  391.     /*** Begin certificate header fields ***/
  392.     *pctb = 0;    /* assume no ctb for caller at first */
  393.     count = fread(&ctb,1,1,f);    /* read key certificate CTB byte */
  394.     if (count==0) return(-1);    /* premature eof */
  395.     *pctb = ctb;    /* returns type to caller */
  396.     if ((ctb != CTB_CERT_PUBKEY) && (ctb != CTB_CERT_SECKEY)  &&
  397.             (ctb != CTB_USERID)  &&  (ctb != CTB_KEYCTRL)  &&
  398.             !is_ctb_type(ctb,CTB_SKE_TYPE) &&
  399.             !is_ctb_type(ctb,CTB_COMMENT_TYPE))
  400.         /* Either bad key packet or X/Ymodem padding detected */
  401.         return ((ctb == 0x1A) ? -1 : -2);
  402.  
  403.     cert_length = getpastlength(ctb, f); /* read certificate length */
  404.  
  405.     if (cert_length > MAX_KEYCERT_LENGTH-3)
  406.         return(-3);    /* bad length */
  407.  
  408.     if (ctb == CTB_USERID)
  409.     {    if (cert_length > 255)
  410.             return(-3);            /* Bad length error */
  411.         if (userid)
  412.         {    userid[0] = cert_length;        /* Save user ID length */
  413.             fread(userid+1,1,cert_length,f); /* read rest of user ID */
  414.         } else
  415.             fseek (f, (long)cert_length, SEEK_CUR);
  416.         return(0);    /* normal return */
  417.     }
  418.     else if (is_ctb_type (ctb, CTB_COMMENT_TYPE))
  419.     {       fseek(f, (long)cert_length, SEEK_CUR);        /* Just skip packet */
  420.         return(0);    /* normal return */
  421.     }
  422.     else if (is_ctb_type (ctb, CTB_SKE_TYPE))
  423.     {    long fpos = ftell(f);        /* Remember where we are now */
  424.         if (sigkeyID)
  425.         {    fread(&version,1,1,f);        /* Read version of sig packet */
  426.             if (version_error(version, VERSION_BYTE))
  427.                 return(-6);            /* Need a later version */
  428.             /* Skip timestamp, validity period, and type byte */
  429.             fread(&mdlen, 1, 1, f);
  430.             fseek(f, (long) mdlen, SEEK_CUR);
  431.             /* Read and return KEY ID */
  432.             fread(sigkeyID,1,KEYFRAGSIZE,f);
  433.         }
  434.         fseek(f,fpos+cert_length,SEEK_SET);    /* Skip to end of cert */
  435.         return(0);    /* normal return */
  436.     }
  437.     else if (ctb == CTB_KEYCTRL)
  438.     {    if (cert_length != 1)
  439.             return(-3);            /* Bad length error */
  440.         if (keyctrl)
  441.             fread(keyctrl,1,cert_length,f);    /* Read key control byte */
  442.         else
  443.             fseek (f, (long)cert_length, SEEK_CUR);
  444.         return(0);    /* normal return */
  445.     }
  446.     /* Here we have a key packet */
  447.     if (n != NULL)
  448.         set_precision(MAX_UNIT_PRECISION);    /* safest opening assumption */
  449.     fread(&version,1,1,f);    /* read and check version */
  450.     if (version_error(version, VERSION_BYTE))
  451.         return(-6);            /* Need a later version */
  452.     if (timestamp)
  453.     {    fread(timestamp,1,SIZEOF_TIMESTAMP,f);    /* read certificate timestamp */
  454.         convert_byteorder(timestamp,SIZEOF_TIMESTAMP); /* convert from external form */
  455.     } else
  456.         fseek(f, (long)SIZEOF_TIMESTAMP, SEEK_CUR);
  457.     fread(&validity,1,sizeof(validity),f);    /* Read validity period */
  458.     convert(validity);    /* convert from external byteorder */
  459.     /* We don't use validity period yet */
  460.     fread (&alg, 1, 1, f);
  461.     if (version_error(alg, RSA_ALGORITHM_BYTE))
  462.         return(-6);            /* Need a later version */
  463.     /*** End certificate header fields ***/
  464.  
  465.     /* We're past certificate headers, now look at some key material...*/
  466.  
  467.     cert_length -= 1 + SIZEOF_TIMESTAMP + 2 + 1;
  468.  
  469.     if (n==NULL)    /* Skip key certificate data */
  470.     {       fseek(f, (long)cert_length, SEEK_CUR);
  471.         return(0);
  472.     }
  473.  
  474.     if (read_mpi(n,f,TRUE,FALSE) < 0)
  475.         return(-4);    /* data corrupted, return error */
  476.  
  477.     /* Note that precision was adjusted for n */
  478.  
  479.     if (read_mpi(e,f,FALSE,FALSE) < 0)
  480.         return(-4);    /* data corrupted, error return */
  481.  
  482.     cert_length -= (countbytes(n)+2) + (countbytes(e)+2);
  483.  
  484.     if (d==NULL)    /* skip rest of this key certificate */
  485.     {       fseek(f, (long)cert_length, SEEK_CUR);
  486.         return(0);            /* Normal return */
  487.     }
  488.     if (is_secret_key(ctb))
  489.     {    byte    alg = 0;
  490.         fread (&alg,1,1,f);
  491.         if (alg && version_error(alg,IDEA_ALGORITHM_BYTE))
  492.             return(-6);            /* Unknown version */
  493.  
  494.         if (!hidekey && alg)
  495.         {    /* Don't bother trying if hidekey is false and alg is true */
  496.             fseek(f, (long)cert_length-1, SEEK_CUR);
  497.             return(-5);
  498.         }
  499.  
  500.         if (alg)    /* if secret components are encrypted... */
  501.         {    /* process encrypted CFB IV before reading secret components */
  502.             count = fread(iv,1,8,f);
  503.             if (count < 8)
  504.                 return(-4);    /* data corrupted, error return */
  505.             ideacfb(iv,8);
  506.             cert_length -= 8;    /* take IV length into account */
  507.         }
  508.  
  509.         /* Reset checksum before these reads */
  510.         mpi_checksum = 0;
  511.  
  512.         if (read_mpi(d,f,FALSE,hidekey) < 0)
  513.             return(-4);    /* data corrupted, error return */
  514.         if (read_mpi(p,f,FALSE,hidekey) < 0)
  515.             return(-4);    /* data corrupted, error return */
  516.         if (read_mpi(q,f,FALSE,hidekey) < 0)
  517.             return(-4);    /* data corrupted, error return */
  518.  
  519.         /* use register 'u' briefly as scratchpad */
  520.         mp_mult(u,p,q);    /* compare p*q against n */
  521.         if (mp_compare(n,u)!=0)    /* bad pass phrase? */
  522.             return(-5);    /* possible bad pass phrase, error return */
  523.         /* now read in real u */
  524.         if (read_mpi(u,f,FALSE,hidekey) < 0)
  525.             return(-4);    /* data corrupted, error return */
  526.  
  527.         /* Read checksum, compare with mpi_checksum */
  528.         fread (&chksum,1,sizeof(chksum),f);
  529.         convert(chksum);
  530.         if (chksum != mpi_checksum)
  531.             return(-5);    /* possible bad pass phrase */
  532.  
  533.         cert_length -= 1 + (countbytes(d)+2) + (countbytes(p)+2) 
  534.             + (countbytes(q)+2) + (countbytes(u)+2) + 2;
  535.  
  536.     }    /* secret key */
  537.     else /* not a secret key */
  538.     {    mp_init(d,0);
  539.         mp_init(p,0);
  540.         mp_init(q,0);
  541.         mp_init(u,0);
  542.     }
  543.  
  544.     if (cert_length != 0)
  545.     {    fprintf(pgpout,"\n\007Corrupted key.  Bad length, off by %d bytes.\n",
  546.             (int) cert_length);
  547.         return(-4);    /* data corrupted, error return */
  548.     }
  549.  
  550.     return(0);    /* normal return */
  551.  
  552. }    /* readkeypacket */
  553.  
  554.  
  555.  
  556. int getpublickey(boolean giveup, boolean showkey, char *keyfile,
  557.     long *file_position, int *pktlen, byte *keyID, byte *timestamp, 
  558.     byte *userid, unitptr n, unitptr e)
  559. /*    keyID contains key fragment we expect to find in keyfile.
  560.     If keyID is NULL, then userid contains a C string search target of
  561.     userid to find in keyfile.
  562.     keyfile is the file to begin search in, and it may be modified
  563.     to indicate true filename of where the key was found.  It can be
  564.     either a public key file or a secret key file.
  565.     file_position is returned as the byte offset within the keyfile
  566.     that the key was found at.  pktlen is the length of the key packet.
  567.     These values are for the key packet itself, not including any
  568.     following userid, control, signature, or comment packets.
  569.     giveup is TRUE iff we are just going to do a single file search only.
  570. */
  571. {
  572.     byte ctb;    /* returned by readkeypacket */
  573.     FILE *f;
  574.     int status;
  575.     boolean keyfound = FALSE;
  576.     boolean secret = FALSE;
  577.     char userid0[256];    /* C string format */
  578.     long fpos, userid_pos;
  579.  
  580.     userid0[0] = '\0';
  581.  
  582.     if (keyID==NULL)    /* then userid has search target */
  583.         strcpy(userid0,(char *)userid);
  584.  
  585. top:
  586.     default_extension(keyfile,PGP_EXTENSION);
  587.  
  588.     if (!file_exists(keyfile))
  589.     {    if (giveup)
  590.             return(-1);    /* give up, error return */
  591.         fprintf(pgpout,PSTR("\n\007Keyring file '%s' does not exist. "),keyfile);
  592.         goto nogood;
  593.     }
  594. #ifdef DEBUG
  595.     if (verbose) fprintf(pgpout,"\nSearching key ring file '%s'.\n",keyfile);
  596. #endif
  597.  
  598.     /* open file f for read, in binary (not text) mode...*/
  599. #ifdef VMS
  600.     if ((f = fopen(keyfile,"rb","ctx=stm")) == NULL)
  601. #else
  602.     if ((f = fopen(keyfile,"rb")) == NULL)
  603. #endif
  604.         return(-1);    /* error return */
  605.  
  606.     while (TRUE) 
  607.     {
  608.         fpos = ftell(f);
  609.         status = readkeypacket(f,FALSE,&ctb,timestamp,(char *)userid,n,e,
  610.                 NULL,NULL,NULL,NULL,NULL,NULL);
  611.         /* Note that readkeypacket has called set_precision */
  612.  
  613.         if (status == -1)    /* end of file */
  614.             break;
  615.  
  616.         if (status < -1)
  617.         {    fprintf(pgpout,PSTR("\n\007Could not read key from file '%s'.\n"),
  618.                 keyfile);
  619.             fclose(f);    /* close key file */
  620.             return(status);
  621.         }
  622.  
  623.         /* Remember packet position and size for last key packet */
  624.         if (is_key_ctb(ctb))
  625.         {    *file_position = fpos;
  626.             *pktlen = (int)(ftell(f) - fpos);
  627.             secret = is_ctb_type(ctb, CTB_CERT_SECKEY_TYPE);
  628.         }
  629.  
  630.         /* Only check for matches when we find a USERID packet */
  631.         if (ctb == CTB_USERID)
  632.         {    /* keyID contains key fragment.  Check it against n from keyfile. */
  633.             if (keyID!=NULL)
  634.                     keyfound = checkkeyID(keyID,n);
  635.             else
  636.             {    /* userid0 is already a C string */
  637.                 PascalToC((char *)userid);    /* for C string functions */
  638.                 /* Accept any matching subset */
  639.                 keyfound = userid_match((char *)userid,userid0);
  640.                 CToPascal((char *)userid);
  641.             }
  642.         }
  643.  
  644.         if (keyfound)
  645.         {    if (showkey)
  646.             {    PascalToC((char *)userid);    /* for display */
  647.                 fprintf(pgpout,PSTR("\nKey for user ID: %s\n"),EXTERNAL((char *)userid));
  648.                 fprintf(pgpout,PSTR("%d-bit key, Key ID %s, created %s\n"),
  649.                     countbits(n), key2IDstring(n), cdate((word32 *)timestamp) );
  650.                 CToPascal((char *)userid);    /* restore after display */
  651. #if 0
  652.                 if (keyID!=NULL)
  653.                 {    /* If a keyID match, display other user ID's */
  654.                     while (readkeypacket(f,FALSE,&ctb,NULL,(char *)userid0,
  655.                             NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL) == 0  &&
  656.                             !is_key_ctb(ctb))
  657.                     {    if (ctb == CTB_USERID)
  658.                         {    PascalToC ((char *)userid0);
  659.                             fprintf (pgpout,PSTR("Also known as: %s\n"),EXTERNAL(userid0));
  660.                         }
  661.                     }
  662.                 }
  663. #else    /* always show all userid's */
  664.                 userid_pos = fpos;
  665.                 if (keyID==NULL)
  666.                     fseek(f, *file_position + *pktlen, SEEK_SET);
  667.                 while (readkeypacket(f,FALSE,&ctb,NULL,(char *)userid0,
  668.                         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL) == 0  &&
  669.                         !is_key_ctb(ctb))
  670.                 {    if (ctb == CTB_USERID)
  671.                     {    PascalToC ((char *)userid0);
  672.                         if (fpos != userid_pos)
  673.                             fprintf (pgpout,PSTR("Also known as: %s\n"),
  674.                                                 userid0);
  675.                     }
  676.                     fpos = ftell(f);
  677.                 }
  678. #endif
  679.             }
  680.             fseek(f, *file_position, SEEK_SET);
  681.             if (is_compromised(f))
  682.             {    fclose(f);
  683.                 return(1);
  684.             }
  685.             fclose(f);
  686.             return(0);    /* normal return */
  687.         }
  688.     }    /* while TRUE */
  689.  
  690.     fclose(f);    /* close key file */
  691.  
  692.     if (giveup)
  693.         return(-1);    /* give up, error return */
  694.  
  695.     if (keyID!=NULL)
  696.     {
  697.         fprintf(pgpout,PSTR("\n\007Key matching expected Key ID %s not found in file '%s'.\n"),
  698.             keyIDstring(keyID),keyfile);
  699.     }
  700.     else
  701.     {    fprintf(pgpout,PSTR("\n\007Key matching userid '%s' not found in file '%s'.\n"),
  702.             EXTERNAL(userid0),keyfile);
  703.     }
  704.  
  705. nogood:
  706.     if (giveup)
  707.         return(-1);    /* give up, error return */
  708.  
  709.     if (secret)
  710.     {    /* Look in public key file and see if it's there. */
  711.         char keyfilename[MAX_PATH];    /* for getpublickey */
  712.         buildfilename(keyfilename,PUBLIC_KEYRING_FILENAME);
  713.         if (getpublickey(TRUE,FALSE,keyfilename,file_position,pktlen,
  714.                 keyID,timestamp,userid,n,e) >= 0)
  715.         {    PascalToC((char * )userid);
  716.             fprintf(pgpout,PSTR("\nThis message can only be read by:\n"));
  717.             fprintf(pgpout,"\"%s\"\n\n",EXTERNAL((char *)userid));
  718.             CToPascal((char *)userid);
  719.         }
  720.         fprintf(pgpout,PSTR("Enter secret key filename: "));
  721.     }
  722.     else
  723.         fprintf(pgpout,PSTR("Enter public key filename: "));
  724.  
  725.     getstring(keyfile,59,TRUE);    /* echo keyboard input */
  726.     if (strlen(keyfile) > 0)
  727.         goto top;
  728.  
  729.     return(-1);    /* give up, error return */
  730.  
  731. }    /* getpublickey */
  732.  
  733. int getpubuserid(char *keyfile, long key_position, byte *userid,
  734.     long *userid_position, int *userid_len)
  735. /*  Start at key_position in keyfile, and scan for the key packet
  736.     that contains userid.  Return userid_position and userid_len.
  737.     Return 0 if OK, -1 on error.  Userid should be a C string.
  738. */
  739. {
  740.     byte ctb;    /* returned by readkeypacket */
  741.     FILE *f;
  742.     int status;
  743.     char userid0[256];    /* C string format */
  744.     long fpos;
  745.  
  746.     /* open file f for read, in binary (not text) mode...*/
  747. #ifdef VMS
  748.     if ((f = fopen(keyfile,"rb","ctx=stm")) == NULL)
  749. #else
  750.     if ((f = fopen(keyfile,"rb")) == NULL)
  751. #endif
  752.         return(-1);    /* error return */
  753.  
  754.     /* Start off at correct location */
  755.     fseek (f, key_position, SEEK_SET);
  756.     (void)nextkeypacket(f, &ctb);    /* Skip key */
  757.     while (TRUE) 
  758.     {
  759.         fpos = ftell(f);
  760.         status = readkeypacket(f,FALSE,&ctb,NULL,(char *)userid0,NULL,NULL,
  761.                 NULL,NULL,NULL,NULL,NULL,NULL);
  762.  
  763.         if (status < 0  ||  is_key_ctb(ctb))
  764.             break;
  765.  
  766.         /* Only check for matches when we find a USERID packet */
  767.         if (ctb == CTB_USERID)
  768.         {    /* userid is already a C string */
  769.             PascalToC((char *)userid0);    /* for C string functions */
  770.             /* Accept any matching subset */
  771.             if (userid_match((char *)userid0, (char *) userid))
  772.             {    *userid_position = fpos;
  773.                 *userid_len = ftell(f) - fpos;
  774.                 fclose(f);
  775.                 return(0);    /* normal return */
  776.             }
  777.         }
  778.     }    /* while TRUE */
  779.  
  780.     fclose(f);    /* close key file */
  781.     return(-1);    /* give up, error return */
  782. }    /* getpubuserid */
  783.  
  784.  
  785. int getpubusersig(char *keyfile, long user_position, byte *sigkeyID,
  786.     long *sig_position, int *sig_len)
  787. /*  Start at user_position in keyfile, and scan for the signature packet
  788.     that matches sigkeyID.  Return sig_position and sig_len.
  789.     Return 0 if OK, -1 on error.
  790. */
  791. {
  792.     byte ctb;    /* returned by readkeypacket */
  793.     FILE *f;
  794.     int status;
  795.     byte keyID0[KEYFRAGSIZE];
  796.     long fpos;
  797.  
  798.     /* open file f for read, in binary (not text) mode...*/
  799. #ifdef VMS
  800.     if ((f = fopen(keyfile,"rb","ctx=stm")) == NULL)
  801. #else
  802.     if ((f = fopen(keyfile,"rb")) == NULL)
  803. #endif
  804.         return(-1);    /* error return */
  805.  
  806.     /* Start off at correct location */
  807.     fseek (f, user_position, SEEK_SET);
  808.     (void)nextkeypacket(f, &ctb);    /* Skip userid packet */
  809.     while (TRUE) 
  810.     {
  811.         fpos = ftell(f);
  812.         status = readkeypacket(f,FALSE,&ctb,NULL,NULL,NULL,NULL,
  813.                 NULL,NULL,NULL,NULL,keyID0,NULL);
  814.  
  815.         if (status < 0  ||  is_key_ctb(ctb)  ||  ctb==CTB_USERID)
  816.             break;
  817.  
  818.         /* Only check for matches when we find a signature packet */
  819.         if (is_ctb_type(ctb,CTB_SKE_TYPE))
  820.         {    if (equal_buffers(sigkeyID,keyID0,KEYFRAGSIZE))
  821.             {    *sig_position = fpos;
  822.                 *sig_len = ftell(f) - fpos;
  823.                 fclose(f);
  824.                 return(0);    /* normal return */
  825.             }
  826.         }
  827.     }    /* while TRUE */
  828.  
  829.     fclose(f);    /* close key file */
  830.     return(-1);    /* give up, error return */
  831. }    /* getpubusersig */
  832.  
  833.  
  834. int getsecretkey(boolean giveup, boolean showkey, char *keyfile, byte *keyID,
  835.     byte *timestamp, char *passp, boolean *hkey,
  836.     byte *userid, unitptr n, unitptr e, unitptr d, unitptr p, unitptr q,
  837.     unitptr u)
  838. /*    keyID contains key fragment we expect to find in keyfile.
  839.     If keyID is NULL, then userid contains search target of
  840.     userid to find in keyfile.
  841.     giveup controls whether we ask the user for the name of the
  842.     secret key file on failure.  showkey controls whether we print
  843.     out the key information when we find it.  keyfile, if non-NULL,
  844.     is the name of the secret key file; if NULL, we use the
  845.     default.  passp and hkey, if non-NULL, get returned with a copy
  846.     of the pass phrase and hidekey variables.
  847. */
  848. {
  849.     byte ctb;    /* returned by readkeypacket */
  850.     FILE *f;
  851.     char keyfilename[MAX_PATH];    /* for getpublickey */
  852.     long file_position;
  853.     int pktlen;    /* unused, just to satisfy getpublickey */
  854.     int status;
  855.     boolean hidekey = FALSE;    /* TRUE iff secret key is encrypted */
  856.     char passphrase[256];
  857.     word16 iv[4];        /* initialization vector for encryption */
  858.     byte ideakey[16];
  859.     char *envkey;
  860.     int guesses = 3;
  861.  
  862.     if (keyfile == NULL)
  863.     {    /* use default pathname */
  864.         buildfilename(keyfilename,SECRET_KEYRING_FILENAME);
  865.         keyfile = keyfilename;
  866.     }
  867.  
  868.     status = getpublickey(giveup, showkey, keyfile, &file_position, &pktlen,
  869.             keyID, timestamp, userid, n, e);
  870.     if (status < 0)
  871.         return(status);    /* error return */
  872.  
  873.  
  874.     /* open file f for read, in binary (not text) mode...*/
  875. #ifdef VMS
  876.     if ((f = fopen(keyfile,"rb","ctx=stm")) == NULL)
  877. #else
  878.     if ((f = fopen(keyfile,"rb")) == NULL)
  879. #endif
  880.         return(-1);    /* error return */
  881.  
  882.     /* First guess is null password, so hidekey is FALSE */
  883.  
  884.     do    /* until good password */
  885.     {    if (hkey != NULL)
  886.             *hkey = hidekey;
  887.         /* Initialize IDEA key */
  888.         if (hidekey)
  889.         {    if (passp != NULL)
  890.                 strcpy (passp, passphrase); /* Save phrase for caller */
  891.             fill0(iv,8);
  892.             initcfb_idea(iv,ideakey,TRUE);
  893.         }
  894.         fseek(f,file_position,SEEK_SET); /* reposition file to key */
  895.         status = readkeypacket(f,hidekey,&ctb,timestamp,(char *)userid,
  896.                         n,e,d,p,q,u,NULL,NULL);
  897.         if (hidekey)
  898.             close_idea();    /* Release resources */
  899.  
  900.         burn((byteptr)passphrase);    /* burn sensitive data on stack */
  901.  
  902.         if (status == -5)    /* bad pass phrase status */
  903.         {    if (guesses!=3)    /* not first guess of null password? */
  904.                 fprintf(pgpout,PSTR("\n\007Error:  Bad pass phrase.\n"));
  905.             if (!hidekey && (envkey = getenv ("PGPPASS")) != NULL)
  906.             { /* Try environment variable second */
  907.                 strncpy (passphrase, envkey, sizeof(passphrase)-1);
  908.                 hashpass (passphrase, strlen(passphrase), ideakey);
  909.                 hidekey = TRUE;
  910.                 continue;
  911.             }
  912.             if (--guesses)    /* not ran out of guesses yet */
  913.             {    fprintf(pgpout,PSTR("\nYou need a pass phrase to unlock your RSA secret key. "));
  914.                 if (!showkey && guesses == 2)
  915.                 {    /* let user know for which key he should type his password */
  916.                     PascalToC((char *)userid);
  917.                     fprintf(pgpout, PSTR("\nKey for user ID \"%s\"\n"), EXTERNAL((char *)userid));
  918.                     CToPascal((char *)userid);
  919.                 }
  920.                 hidekey = (getideakey(passphrase, (char *) ideakey, 1) > 0);
  921.                 continue;    /* take it from the top */
  922.             }    /* more guesses to go */
  923.         }
  924.         if (status < 0)
  925.         {    fprintf(pgpout,PSTR("\n\007Could not read key from file '%s'.\n"),
  926.                 keyfile);
  927.             fclose(f);    /* close key file */
  928.             return(-1);
  929.         }
  930.     }    while (status < 0);    /* until key reads OK, with good password */
  931.  
  932.     fclose(f);    /* close key file */
  933.  
  934.     /* Note that readkeypacket has called set_precision */
  935.  
  936.     if (d != NULL)        /* No effective check of pass phrase if d is NULL */
  937.     {    if (!hidekey)
  938.             fprintf(pgpout,PSTR("\nAdvisory warning: This RSA secret key is not protected by a passphrase.\n"));
  939.         else
  940.             fprintf(pgpout,PSTR("Pass phrase is good.  "));
  941.  
  942.         if (testeq(d,0))    /* didn't get secret key components */
  943.         {    fprintf(pgpout,PSTR("\n\007Key file '%s' is not a secret key file.\n"),keyfile);
  944.             return(-1);
  945.         }
  946.     }
  947.  
  948.     return(0);    /* normal return */
  949.  
  950. }    /* getsecretkey */
  951.  
  952.  
  953. int is_compromised(FILE *f)
  954. /* check if a key has a compromise certificate, file pointer must
  955.    be positioned at or right after the key packet.
  956. */
  957. {
  958.     long pos, savepos;
  959.     byte class, ctb;
  960.     int cert_len;
  961.     int status = 0;
  962.  
  963.     pos = savepos = ftell(f);
  964.  
  965.     nextkeypacket(f, &ctb);
  966.     if (is_key_ctb(ctb))
  967.     {    pos = ftell(f);
  968.         nextkeypacket(f, &ctb);
  969.     }
  970.     if (ctb != CTB_KEYCTRL)
  971.         fseek(f, pos, SEEK_SET);
  972.  
  973.     /* file pointer now positioned where compromise cert. should be */
  974.     if (fread(&ctb, 1, 1, f) != 1)
  975.     {    status = -1;
  976.         goto ex;
  977.     }
  978.     
  979.     if (is_ctb_type(ctb, CTB_SKE_TYPE))
  980.     {
  981.         cert_len = getpastlength(ctb, f);
  982.         if (cert_len > MAX_SIGCERT_LENGTH)    /* Huge packet length */
  983.         {    status = -1;
  984.             goto ex;
  985.         }
  986.  
  987.         /* skip version and mdlen byte */
  988.         fseek(f, 2L, SEEK_CUR);
  989.         if (fread(&class, 1, 1, f) != 1)
  990.         {    status = -1;
  991.             goto ex;
  992.         }
  993.         status = (class == KC_SIGNATURE_BYTE);
  994.     }
  995. ex:
  996.     fseek(f, savepos, SEEK_SET);
  997.     return(status);
  998. }
  999.  
  1000.  
  1001. /*    Alfred Hitchcock coined the term "mcguffin" for the generic object 
  1002.     being sought in his films-- the diamond, the microfilm, etc. 
  1003. */
  1004.  
  1005. int view_keyring(char *mcguffin, char *ringfile, boolean show_signatures)
  1006. /*    Lists all entries in keyring that have mcguffin string in userid.
  1007.     mcguffin is a null-terminated C string.
  1008. */
  1009. {    FILE *f;
  1010.     byte ctb, keyctb;
  1011.     long fpr;
  1012.     int pktlenr;
  1013.     int status;
  1014.     unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION];
  1015.     byte keyID[KEYFRAGSIZE];
  1016.     byte sigkeyID[KEYFRAGSIZE];
  1017.     byte userid[256];        /* key certificate userid */
  1018.     char dfltring[MAX_PATH];
  1019.     word32 tstamp;
  1020.     byte *timestamp = (byte *) &tstamp;        /* key certificate timestamp */
  1021.     int keycounter = 0;
  1022.     int firstuser = 0;
  1023.     int compromised = 0;
  1024.  
  1025.     /* Default keyring to check signature ID's */
  1026.     buildfilename(dfltring,PUBLIC_KEYRING_FILENAME);
  1027.  
  1028.     /* open file f for read, in binary (not text) mode...*/
  1029. #ifdef VMS
  1030.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1031. #else
  1032.     if ((f = fopen(ringfile,"rb")) == NULL)
  1033. #endif
  1034.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1035.         return(-1);
  1036.     }
  1037.  
  1038. /*    Here's a good format for display of key or signature certificates:
  1039. Type bits/keyID   Date       User ID
  1040. pub  1024/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1041. sec   512/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1042. sig   384/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1043. */
  1044.  
  1045.     fprintf(pgpout,PSTR("\nKey ring: '%s'"),ringfile);
  1046.     if (mcguffin && strlen(mcguffin) > 0)
  1047.         fprintf(pgpout,PSTR(", looking for user ID \"%s\"."),EXTERNAL(mcguffin));
  1048.     fprintf(pgpout,PSTR("\nType bits/keyID   Date       User ID\n"));
  1049.     for ( ; ; )
  1050.     {
  1051.         status = readkeypacket(f,FALSE,&ctb,timestamp,(char *)userid,n,e,
  1052.                 NULL,NULL,NULL,NULL,sigkeyID,NULL);
  1053.         /* Note that readkeypacket has called set_precision */
  1054.         if (status== -1)
  1055.         {    status = 0;
  1056.             break;    /* eof reached */
  1057.         }
  1058.         if (status < 0)
  1059.         {    fprintf(pgpout,PSTR("\n\007Could not read key from file '%s'.\n"),
  1060.                 ringfile);
  1061.             break;
  1062.         }
  1063.  
  1064.         if (is_key_ctb(ctb))
  1065.         {    keycounter++;
  1066.             firstuser = 1;
  1067.             keyctb = ctb;
  1068.             compromised = is_compromised(f);
  1069.         }
  1070.  
  1071.         if (ctb != CTB_USERID  &&  !is_ctb_type(ctb, CTB_SKE_TYPE))
  1072.             continue;
  1073.         extract_keyID(keyID, n);
  1074.         PascalToC((char *)userid);
  1075.  
  1076.         if (userid_match((char *)userid,mcguffin))
  1077.         {
  1078.             if (ctb == CTB_USERID)
  1079.             {    if (firstuser)
  1080.                 {    if (is_ctb_type(keyctb,CTB_CERT_PUBKEY_TYPE))
  1081.                         fprintf(pgpout,"pub  ");
  1082.                     else if (is_ctb_type(keyctb,CTB_CERT_SECKEY_TYPE))
  1083.                         fprintf(pgpout,"sec  ");
  1084.                     else
  1085.                         fprintf(pgpout,"???  ");
  1086.                     fprintf(pgpout,"%4d/%s %s  ",
  1087.                         countbits(n),keyIDstring(keyID),cdate(&tstamp));
  1088.                 }
  1089.                 else
  1090.                     fprintf(pgpout,"                             ");
  1091.                 if (compromised && firstuser)
  1092.                 {    fprintf(pgpout, PSTR("*** KEY REVOKED ***\n"));
  1093.                     fprintf(pgpout,"                             ");
  1094.                 }
  1095.                 firstuser = 0;
  1096.                 fprintf(pgpout,"%s\n",EXTERNAL((char *)userid));
  1097.             }
  1098.             else if (show_signatures && !(firstuser && compromised))    /* Must be sig cert */
  1099.             {    fprintf(pgpout,"sig       ");
  1100.                 showkeyID(sigkeyID);
  1101.                 fprintf(pgpout,"              "); /* Indent userid */
  1102.                 if (getpublickey(TRUE, FALSE, ringfile, &fpr, &pktlenr,
  1103.                                  sigkeyID, timestamp, userid, n, e)>=0 ||
  1104.                     getpublickey(TRUE, FALSE, dfltring, &fpr, &pktlenr,
  1105.                                  sigkeyID, timestamp, userid, n, e)>=0)
  1106.                 {    PascalToC((char *)userid);
  1107.                     fprintf(pgpout,"%s\n",EXTERNAL((char *)userid));
  1108.                 }
  1109.                 else
  1110.                     fprintf(pgpout,PSTR("(Unknown signator, can't be checked)\n"));
  1111.             } /* printing a sig cert */
  1112.         }    /* if it has mcguffin */
  1113.     }    /* loop for all packets */
  1114.  
  1115.     fclose(f);    /* close key file */
  1116.     fprintf(pgpout,PSTR("%d key(s) examined.\n"),keycounter);
  1117.  
  1118.     return(status);    /* normal return */
  1119.  
  1120. }    /* view_keyring */
  1121.  
  1122.  
  1123. int dokeycheck(char *mcguffin, char *ringfile, byte *chk_keyID)
  1124. /*    Lists all entries in keyring that have mcguffin string in userid.
  1125.     mcguffin is a null-terminated C string.
  1126. */
  1127. {    FILE *f, *fixedf;
  1128.     byte ctb, keyctb;
  1129.     long fpsig, fpkey, fixpos = 0;
  1130.     int status, sigstatus;
  1131.     int keypktlen, sigpktlen;
  1132.     unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION];
  1133.     byte keyID[KEYFRAGSIZE];
  1134.     byte sigkeyID[KEYFRAGSIZE];
  1135.     byte keyuserid[256];        /* key certificate userid */
  1136.     byte siguserid[256];        /* sig certificate userid */
  1137.     char dfltring[MAX_PATH];
  1138.     char *tempring;
  1139.     word32 tstamp;
  1140.     byte *timestamp = (byte *) &tstamp;        /* key certificate timestamp */
  1141.     word32 sigtstamp;
  1142.     byte *sigtimestamp = (byte *) &sigtstamp;
  1143.     byte sigclass;
  1144.     int firstuser = 0;
  1145.     int compromised = 0;
  1146.     boolean failed=FALSE;
  1147.  
  1148.     /* Default keyring to check signature ID's */
  1149.     buildfilename(dfltring,PUBLIC_KEYRING_FILENAME);
  1150.  
  1151.     /* open file f for read, in binary (not text) mode...*/
  1152. #ifdef VMS
  1153.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1154. #else
  1155.     if ((f = fopen(ringfile,"rb")) == NULL)
  1156. #endif
  1157.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1158.         return(-1);
  1159.     }
  1160.  
  1161. /*    Here's a good format for display of key or signature certificates:
  1162. Type bits/keyID   Date       User ID
  1163. pub  1024/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1164. sec   512/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1165. sig   384/xxxxxx yyyy-mm-dd  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  1166. */
  1167.  
  1168.     if (!chk_keyID)
  1169.     {    fprintf(pgpout,PSTR("\nKey ring: '%s'"),ringfile);
  1170.         if (mcguffin && strlen(mcguffin) > 0)
  1171.             fprintf(pgpout,PSTR(", looking for user ID \"%s\"."),EXTERNAL(mcguffin));
  1172.         fprintf(pgpout,PSTR("\nType bits/keyID   Date       User ID\n"));
  1173.     }
  1174.     for ( ; ; )
  1175.     {    long fpos = ftell(f);
  1176.         status = readkeypacket(f,FALSE,&ctb,timestamp,(char *)keyuserid,n,e,
  1177.                 NULL,NULL,NULL,NULL,sigkeyID,NULL);
  1178.         /* Note that readkeypacket has called set_precision */
  1179.         if (status== -1 ) break;    /* eof reached */
  1180.         if (status < 0)
  1181.         {    fprintf(pgpout,PSTR("\n\007Could not read key from file '%s'.\n"),
  1182.                 ringfile);
  1183.             fclose(f);    /* close key file */
  1184.             return(-1);
  1185.         }
  1186.  
  1187.         if (is_key_ctb(ctb))
  1188.         {    firstuser = 1;
  1189.             keyctb = ctb;
  1190.             fpkey = fpos;
  1191.             keypktlen = ftell(f) - fpkey;
  1192.             extract_keyID(keyID, n);
  1193.             compromised = is_compromised(f);
  1194.         }
  1195.  
  1196.         if (ctb != CTB_USERID  &&  !is_ctb_type(ctb, CTB_SKE_TYPE))
  1197.             continue;
  1198.         if (ctb == CTB_USERID)
  1199.             PascalToC((char *)keyuserid);
  1200.  
  1201.         if (chk_keyID || userid_match((char *)keyuserid,mcguffin))
  1202.         {
  1203.             if (ctb == CTB_USERID)
  1204.             {    if (chk_keyID)
  1205.                     continue;
  1206.                 if (firstuser)
  1207.                 {    if (is_ctb_type(keyctb,CTB_CERT_PUBKEY_TYPE))
  1208.                         fprintf(pgpout,"pub  ");
  1209.                     else if (is_ctb_type(keyctb,CTB_CERT_SECKEY_TYPE))
  1210.                         fprintf(pgpout,"sec  ");
  1211.                     else
  1212.                         fprintf(pgpout,"???  ");
  1213.                     fprintf(pgpout,"%4d/%s %s  ",
  1214.                         countbits(n),keyIDstring(keyID),cdate(&tstamp));
  1215.                 }
  1216.                 else
  1217.                     fprintf(pgpout,"                             ");
  1218.                 if (compromised && firstuser)
  1219.                 {    fprintf(pgpout, PSTR("*** KEY REVOKED ***\n"));
  1220.                     fprintf(pgpout,"                             ");
  1221.                 }
  1222.                 firstuser = 0;
  1223.                 fprintf(pgpout,"%s\n",EXTERNAL((char *)keyuserid));
  1224.             }
  1225.             else /* Must be sig cert */
  1226.             {    /* Try checking signature on either this ring or dflt ring */
  1227.                 if (chk_keyID && memcmp(chk_keyID, sigkeyID, KEYFRAGSIZE))
  1228.                     continue;    /* only check signatures from chk_keyID */
  1229.                 fpsig = fpos;
  1230.                 sigpktlen = ftell(f) - fpsig;
  1231.                 CToPascal((char *)keyuserid);
  1232.                 sigstatus = check_key_sig (f, fpkey, keypktlen, (char *) keyuserid,
  1233.                     f, fpsig, ringfile, (char *) siguserid, sigtimestamp, &sigclass);
  1234.                 if (sigstatus == -1  &&  strcmp(ringfile,dfltring) != 0)
  1235.                     sigstatus = check_key_sig (f, fpkey, keypktlen, (char *) keyuserid,
  1236.                         f, fpsig, dfltring, (char *) siguserid, sigtimestamp, &sigclass);
  1237.                 PascalToC((char *)keyuserid);
  1238.                 fseek (f, fpsig+sigpktlen, SEEK_SET);
  1239.                 if (sigclass == KC_SIGNATURE_BYTE)
  1240.                     fprintf(pgpout,"com");
  1241.                 else
  1242.                     fprintf(pgpout,"sig");
  1243.                 if (sigstatus >= 0)
  1244.                     fprintf(pgpout,"!      ");
  1245.                 else if (sigstatus == -1)
  1246.                     fprintf(pgpout,"?      ");
  1247.                 else
  1248.                     fprintf(pgpout,"*      ");
  1249.                 showkeyID(sigkeyID);
  1250.                 if (sigstatus >= 0)
  1251.                 {    PascalToC((char *) siguserid);
  1252.                     fprintf(pgpout," %s  ",cdate(&sigtstamp));
  1253.                     if (sigclass != KC_SIGNATURE_BYTE)
  1254.                         fprintf(pgpout, "  ");
  1255.                     fprintf(pgpout,"%s\n", EXTERNAL((char *)siguserid));
  1256.                 }
  1257.                 else if (sigstatus == -1)
  1258.                 {    fprintf(pgpout,"              ");
  1259.                     fprintf(pgpout,PSTR("(Unknown signator, can't be checked)\n"));
  1260.                 }
  1261.                 else
  1262.                 {    fprintf(pgpout,"              ");
  1263.                     fprintf(pgpout,PSTR("\007***** BAD SIGNATURE! *****\n"));
  1264.                     if (!failed)
  1265.                     {    /* first bad signature: create scratch file */
  1266.                         tempring = tempfile(TMP_TMPDIR);
  1267.                         fixedf = fopenbin(tempring, "w");
  1268.                         failed = TRUE;
  1269.                     }
  1270.                     if (fixedf != NULL)
  1271.                     {
  1272.                         copyfilepos(f, fixedf, fpsig - fixpos, fixpos);
  1273.                         fseek(f, fpsig+sigpktlen, SEEK_SET);
  1274.                         if (nextkeypacket(f, &ctb) < 0 || ctb != CTB_KEYCTRL)
  1275.                             fseek(f, fpsig+sigpktlen, SEEK_SET);
  1276.                         fixpos = ftell(f);
  1277.                     }
  1278.                 }
  1279.             } /* checking a signature */
  1280.         }    /* if it has mcguffin */
  1281.     }    /* loop for all packets */
  1282.  
  1283.     if (!chk_keyID)
  1284.         fputc('\n',pgpout);
  1285.  
  1286.     if (failed)
  1287.     {
  1288.         copyfilepos(f, fixedf, -1L, fixpos);
  1289.         fclose(fixedf);
  1290.         fprintf(pgpout, PSTR("Remove bad signatures (Y/n)? "));
  1291.         if (getyesno('y'))
  1292.         {
  1293.             savetempbak(tempring, ringfile);
  1294.             failed = 0;
  1295.         }
  1296.     }
  1297.     fclose(f);    /* close key file */
  1298.  
  1299.     return(failed?-1:0);    /* normal return */
  1300.  
  1301. }    /* dokeycheck */
  1302.  
  1303. int backup_rename(char *scratchfile, char *destfile)
  1304. {    /* rename scratchfile to destfile after making a backup file */
  1305.     char bakfile[MAX_PATH];
  1306.  
  1307.     if (strcmp(destfile, SCRATCH_KEYRING_PATH) == 0 ||
  1308.             is_tempfile(destfile))
  1309.     {
  1310.         remove(destfile);
  1311.     }
  1312.     else
  1313.     {    if (file_exists(destfile))
  1314.         {
  1315.             strcpy(bakfile, destfile);
  1316.             force_extension(bakfile, BAK_EXTENSION);
  1317.             remove(bakfile);
  1318.             rename(destfile, bakfile);
  1319.         }
  1320.     }
  1321.     return(rename2(scratchfile, destfile));
  1322. }
  1323.  
  1324. int remove_sigs(char *mcguffin, char*ringfile)
  1325. /* Lists all signatures for keys with specified mcguffin string, and asks
  1326.  * if they should be removed.
  1327.  */
  1328. {    FILE *f, *g;
  1329.     byte ctb;
  1330.     long fp, fpr, fpuser;
  1331.     int packetlength, pktlenr;
  1332.     int status;
  1333.     unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION];
  1334.     byte sigkeyID[KEYFRAGSIZE];
  1335.     byte userid[256];        /* key certificate userid */
  1336.     char dfltring[MAX_PATH];
  1337.     word32 tstamp;
  1338.     byte *timestamp = (byte *) &tstamp;        /* key certificate timestamp */
  1339.     int nsigs = 0, nremoved = 0;
  1340.     int keeping;
  1341.  
  1342.     /* Default keyring to check signature ID's */
  1343.     buildfilename(dfltring,PUBLIC_KEYRING_FILENAME);
  1344.  
  1345.     if (build_path(SCRATCH_KEYRING_PATH,SCRATCH_KEYRING_FILENAME,ringfile)<0)
  1346.         return(-1);    /* Error, file path too long */
  1347.  
  1348.     if (!mcguffin  ||  strlen(mcguffin) == 0)
  1349.         return(-1);
  1350.  
  1351.     strcpy((char *)userid,mcguffin);
  1352.  
  1353.     fprintf(pgpout,PSTR("\nRemoving signatures from userid '%s' in key ring '%s'\n"),
  1354.                 EXTERNAL(mcguffin), ringfile);
  1355.  
  1356.     status = getpublickey(TRUE, TRUE, ringfile, &fp, &packetlength, NULL, timestamp, userid, n, e);
  1357.     if (status < 0)
  1358.     {    fprintf(pgpout,PSTR("\n\007Key not found in key ring '%s'.\n"),ringfile);
  1359.         return(0);    /* normal return */
  1360.     }
  1361.  
  1362.     strcpy((char *)userid,mcguffin);
  1363.     getpubuserid (ringfile, fp, userid, &fpuser, &packetlength);
  1364.     packetlength += fpuser - fp;
  1365.  
  1366.     /* open file f for read, in binary (not text) mode...*/
  1367. #ifdef VMS
  1368.     if ((f = fopen(ringfile,"rb","ctx=stm","ctx=stm")) == NULL)
  1369. #else
  1370.     if ((f = fopen(ringfile,"rb")) == NULL)
  1371. #endif
  1372.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1373.         return(-1);
  1374.     }
  1375.  
  1376.     /* Count signatures */
  1377.     fseek (f, fp+packetlength, SEEK_SET);
  1378.     for ( ; ; )
  1379.     {    status = nextkeypacket(f, &ctb);
  1380.         if (status < 0  ||  is_key_ctb(ctb)  ||  ctb==CTB_USERID)
  1381.             break;
  1382.         if (is_ctb_type(ctb,CTB_SKE_TYPE))
  1383.             ++nsigs;
  1384.     }
  1385.         
  1386.     rewind(f);
  1387.  
  1388.     if (nsigs == 0)
  1389.     {    fprintf (pgpout,PSTR("\nKey has no signatures to remove.\n"));
  1390.         fclose (f);
  1391.         return (0);        /* Normal return */
  1392.     }
  1393.  
  1394.     fprintf (pgpout, PSTR("\nKey has %d signature(s):\n"), nsigs);
  1395.  
  1396.     remove(SCRATCH_KEYRING_PATH);
  1397.     /* open file g for writing, in binary (not text) mode...*/
  1398. #ifdef VMS
  1399.     if ((g = fopen(SCRATCH_KEYRING_PATH,"wb","ctx=stm")) == NULL)
  1400. #else
  1401.     if ((g = fopen(SCRATCH_KEYRING_PATH,"wb")) == NULL)
  1402. #endif
  1403.     {    fclose(f);
  1404.         return(-1);
  1405.     }
  1406.     copyfile(f,g,fp+packetlength);    /* copy file f to g up through key */
  1407.  
  1408.     /* Now print out any following sig certs */
  1409.     keeping = 1;
  1410.     for ( ; ; )
  1411.     {    fp = ftell(f);
  1412.         status = readkeypacket(f, FALSE, &ctb, NULL, NULL, NULL, NULL,
  1413.                 NULL,NULL,NULL,NULL,sigkeyID,NULL);
  1414.         packetlength = ftell(f) - fp;
  1415.         if (status < 0  ||  is_key_ctb(ctb)  ||  ctb==CTB_USERID)
  1416.             break;
  1417.         if (is_ctb_type(ctb,CTB_SKE_TYPE))
  1418.         {    fprintf(pgpout,"sig      ");
  1419.             showkeyID(sigkeyID);
  1420.             fprintf(pgpout,"              "); /* Indent userid */
  1421.             if (getpublickey(TRUE, FALSE, ringfile, &fpr, &pktlenr,
  1422.                              sigkeyID, timestamp, userid, n, e)>=0 ||
  1423.                 getpublickey(TRUE, FALSE, dfltring, &fpr, &pktlenr,
  1424.                              sigkeyID, timestamp, userid, n, e)>=0)
  1425.             {    PascalToC((char *)userid);
  1426.                 fprintf(pgpout,"%s\n",EXTERNAL((char *)userid));
  1427.             }
  1428.             else
  1429.                 fprintf(pgpout,PSTR("(Unknown signator, can't be checked)\n"));
  1430.             fprintf(pgpout, PSTR("Remove this signature (y/N)? "));
  1431.             if (!(keeping=!getyesno('n')))
  1432.                 ++nremoved;
  1433.         }
  1434.         if (keeping)
  1435.             copyfilepos (f, g, packetlength, fp);
  1436.     }    /* scanning sig certs */
  1437.     copyfilepos (f, g, -1L, fp);        /* Copy rest of file */
  1438.  
  1439.     fclose(g);    /* close scratch file */
  1440.     fclose(f);    /* close key file */
  1441.     backup_rename(SCRATCH_KEYRING_PATH,ringfile);
  1442.     if (nremoved == 0)
  1443.         fprintf(pgpout,PSTR("\nNo key signatures removed.\n"));
  1444.     else
  1445.         fprintf(pgpout,PSTR("\n%d key signature(s) removed.\n"), nremoved);
  1446.  
  1447.     return(0);    /* normal return */
  1448.  
  1449. }    /* remove_sigs */
  1450.  
  1451.  
  1452. int remove_from_keyring(byte *keyID, char *mcguffin, char *ringfile)
  1453. /*    Remove the first entry in key ring that has mcguffin string in userid.
  1454.     Or it removes the first matching keyID from the ring.
  1455.     A non-NULL keyID takes precedence over a mcguffin specifier.
  1456.     mcguffin is a null-terminated C string.
  1457. */
  1458. {
  1459.     FILE *f;
  1460.     FILE *g;
  1461.     long fp, nfp;
  1462.     int packetlength;
  1463.     byte ctb;
  1464.     int status;
  1465.     unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION];
  1466.     byte userid[256];        /* key certificate userid */
  1467.     word32 tstamp; byte *timestamp = (byte *) &tstamp;        /* key certificate timestamp */
  1468.     int userids;
  1469.     boolean rmuserid = FALSE;
  1470.  
  1471.     default_extension(ringfile,PGP_EXTENSION);
  1472.     if (build_path(SCRATCH_KEYRING_PATH,SCRATCH_KEYRING_FILENAME,ringfile)<0)
  1473.         return(-1);    /* Error, file path too long */
  1474.  
  1475.     if ((keyID==NULL) && (!mcguffin  ||  strlen(mcguffin)==0))
  1476.         return(-1); /* error, null mcguffin will match everything */
  1477.  
  1478.     if (mcguffin)
  1479.         strcpy((char *)userid,mcguffin);
  1480.  
  1481.     fprintf(pgpout,PSTR("\nRemoving from key ring: '%s'"),ringfile);
  1482.     if (mcguffin  &&  strlen(mcguffin) > 0)
  1483.         fprintf(pgpout,PSTR(", userid \"%s\".\n"),EXTERNAL(mcguffin));
  1484.  
  1485.     status = getpublickey(TRUE, TRUE, ringfile, &fp, &packetlength, NULL, timestamp, userid, n, e);
  1486.     if (status < 0)
  1487.     {    fprintf(pgpout,PSTR("\n\007Key not found in key ring '%s'.\n"),ringfile);
  1488.         return(0);    /* normal return */
  1489.     }
  1490.  
  1491.     /* Now add to packetlength the subordinate following certificates */
  1492. #ifdef VMS
  1493.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1494. #else
  1495.     if ((f = fopen(ringfile,"rb")) == NULL)
  1496. #endif
  1497.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1498.         return(-1);
  1499.     }
  1500.     fseek (f, fp+packetlength, SEEK_SET);
  1501.     userids = 0;
  1502.     do     /* count user ID's, position nfp at next key */
  1503.     {    nfp = ftell(f);
  1504.         status = nextkeypacket(f, &ctb);
  1505.         if (status == 0 && ctb == CTB_USERID)
  1506.             ++userids;
  1507.     } while (status == 0 && !is_key_ctb(ctb));
  1508.     if (status < -1)
  1509.     {    fclose(f);
  1510.         return(-1);
  1511.     }
  1512.  
  1513.     if (keyID==NULL)    /* Human confirmation is required. */
  1514.     {    /* Supposedly the key was fully displayed by getpublickey */
  1515.         if (userids > 1)
  1516.         {    fprintf(pgpout, PSTR("\nKey has more than one user ID.\n\
  1517. Do you want to remove the whole key (y/N)? "));
  1518.             if (!getyesno('n'))
  1519.             {    /* find out which userid should be removed */
  1520.                 fseek (f, fp+packetlength, SEEK_SET);
  1521.                 for ( ; ; )
  1522.                 {    fp = ftell(f);
  1523.                     status = readkpacket(f, &ctb, (char *) userid, NULL, NULL);
  1524.                     if (status < 0 || is_key_ctb(ctb))
  1525.                     {    fclose(f);
  1526.                         fprintf(pgpout, PSTR("\nNo more user ID's\n"));
  1527.                         return(-1);
  1528.                     }
  1529.                     if (ctb == CTB_USERID)
  1530.                     {    fprintf(pgpout, PSTR("Remove \"%s\" (y/N)? "), userid);
  1531.                         if (getyesno('n'))
  1532.                             break;
  1533.                     }
  1534.                 }
  1535.                 do     /* also remove signatures and trust bytes */
  1536.                 {    nfp = ftell(f);
  1537.                     status = nextkeypacket(f, &ctb);
  1538.                 } while (status == 0  && !is_key_ctb(ctb) && ctb != CTB_USERID);
  1539.                 if (status < -1)
  1540.                 {    fclose(f);
  1541.                     return(-1);
  1542.                 }
  1543.             }
  1544.             rmuserid = TRUE;
  1545.         }
  1546.         else    /* only one user ID */
  1547.         {    fprintf(pgpout,
  1548.                 PSTR("\nAre you sure you want this key removed (y/N)? "));
  1549.             if (!getyesno('n'))
  1550.             {    fclose(f);
  1551.                 return(-1);    /* user said "no" */
  1552.             }
  1553.         }
  1554.     }
  1555.     fclose(f);
  1556.     packetlength = nfp - fp;
  1557.  
  1558.     /* open file f for read, in binary (not text) mode...*/
  1559. #ifdef VMS
  1560.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1561. #else
  1562.     if ((f = fopen(ringfile,"rb")) == NULL)
  1563. #endif
  1564.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1565.         return(-1);
  1566.     }
  1567.  
  1568.     remove(SCRATCH_KEYRING_PATH);
  1569.     /* open file g for writing, in binary (not text) mode...*/
  1570.     if ((g = fopen(SCRATCH_KEYRING_PATH,"wb")) == NULL)
  1571.     {    fclose(f);
  1572.         return(-1);
  1573.     }
  1574.     copyfilepos(f,g,fp,0L);    /* copy file f to g up to position fp */
  1575.     copyfilepos(f,g,-1L,fp+packetlength); /* copy rest of file f */
  1576.     fclose(g);    /* close scratch file */
  1577.     fclose(f);    /* close key file */
  1578.     backup_rename(SCRATCH_KEYRING_PATH,ringfile);
  1579.     if (rmuserid)
  1580.         fprintf(pgpout,PSTR("\nUser ID removed from key ring.\n"));
  1581.     else
  1582.         fprintf(pgpout,PSTR("\nKey removed from key ring.\n"));
  1583.  
  1584.     return(0);    /* normal return */
  1585.  
  1586. }    /* remove_from_keyring */
  1587.  
  1588.  
  1589. int extract_from_keyring (char *mcguffin, char *keyfile, char *ringfile,
  1590.                 boolean transflag)
  1591. /*    Copy the first entry in key ring that has mcguffin string in
  1592.     userid and put it into keyfile.
  1593.     mcguffin is a null-terminated C string.
  1594. */
  1595. {
  1596.     FILE *f;
  1597.     FILE *g;
  1598.     long fp, dummy_fp;
  1599.     int packetlength=0, dummy_packetlength;
  1600.     byte ctb;
  1601.     int status;
  1602.     unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION];
  1603.     byte keyID[KEYFRAGSIZE];
  1604.     byte userid[256];    /* key certificate userid */
  1605.     char fname[MAX_PATH], transfile[MAX_PATH], transname[MAX_PATH];
  1606.     word32 tstamp; byte *timestamp = (byte *) &tstamp; /* key cert tstamp */
  1607.     boolean append = FALSE;
  1608.     boolean whole_ring = FALSE;
  1609.  
  1610.     default_extension(ringfile, PGP_EXTENSION);
  1611.  
  1612.     if (!mcguffin  ||  strlen(mcguffin)==0 || strcmp(mcguffin, "*") == 0)
  1613.         whole_ring = TRUE;
  1614.  
  1615.     /* open file f for read, in binary (not text) mode...*/
  1616. #ifdef VMS
  1617.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1618. #else
  1619.     if ((f = fopen(ringfile,"rb")) == NULL)
  1620. #endif
  1621.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1622.         return(-1);
  1623.     }
  1624.  
  1625.     if (!whole_ring)
  1626.     {
  1627.         strcpy((char *)userid, mcguffin);
  1628.         fprintf(pgpout,PSTR("\nExtracting from key ring: '%s'"),ringfile);
  1629.         fprintf(pgpout,PSTR(", userid \"%s\".\n"),EXTERNAL(mcguffin));
  1630.  
  1631.         status = getpublickey(TRUE, TRUE, ringfile, &fp, &packetlength, NULL,
  1632.                     timestamp, userid, n, e);
  1633.         if (status < 0)
  1634.         {    fprintf(pgpout,PSTR("\n\007Key not found in key ring '%s'.\n"),
  1635.                                     ringfile);
  1636.             fclose(f);
  1637.             return(0);    /* normal return */
  1638.         }
  1639.         extract_keyID(keyID, n);
  1640.     }
  1641.     else
  1642.     {
  1643.         do    /* set fp to first key packet */
  1644.             fp = ftell(f);
  1645.         while ((status = nextkeypacket(f, &ctb)) >= 0 && !is_key_ctb(ctb));
  1646.         if (status < 0)
  1647.         {    fclose(f);
  1648.             return(-1);
  1649.         }
  1650.         packetlength = ftell(f) - fp;
  1651.     }
  1652.  
  1653.     if (!keyfile  ||  strlen(keyfile)==0)
  1654.     {    fprintf(pgpout, PSTR("\nExtract the above key into which file? "));
  1655.         getstring( fname, sizeof(fname)-4, TRUE );
  1656.     }
  1657.     else
  1658.         strcpy(fname,keyfile);
  1659.     default_extension(fname,PGP_EXTENSION);
  1660.  
  1661.     /* If transport armoring, use a dummy file for keyfile */
  1662.     if (transflag)
  1663.     {    strcpy(transname, fname);
  1664.         strcpy(transfile, fname);
  1665.         force_extension(transfile, ASC_EXTENSION);
  1666.         strcpy (fname, SCRATCH_KEYRING_FILENAME);
  1667.     }
  1668.     if (file_exists( transflag?transfile:fname ))
  1669.     {
  1670.         if (!transflag && !whole_ring)
  1671.         {    /* see if the key is already present in fname */
  1672.             status = getpublickey(TRUE, FALSE, fname, &dummy_fp, &dummy_packetlength,
  1673.                     keyID, timestamp, userid, n, e);
  1674.             if (status >= 0)
  1675.             {    fclose(f);
  1676.                 fprintf(pgpout,PSTR("Key ID %s is already included in key ring '%s'.\n"),
  1677.                     keyIDstring(keyID), fname);
  1678.                 return(-1);
  1679.             }
  1680.         }
  1681.         if (whole_ring || transflag || status < -1)
  1682.         { /* if status < -1 then fname is not a keyfile, ask if it should be overwritten */
  1683.             fprintf(pgpout,PSTR("\n\007Output file '%s' already exists.  Overwrite (y/N)? "),
  1684.                 fname);
  1685.             if (!getyesno( 'n' ))
  1686.             {    fclose(f);
  1687.                 return(-1);    /* user chose to abort */
  1688.             }
  1689.         }
  1690.         else
  1691.             append = TRUE;
  1692.     }
  1693.  
  1694.     if ((g = fopen(fname,(append ? "r+b" : "wb"))) == NULL)
  1695.     {    if (append)
  1696.             fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1697.         else
  1698.             fprintf(pgpout,PSTR("\n\007Unable to create key file '%s'.\n"), fname);
  1699.         fclose(f);
  1700.         return(-1);
  1701.     }
  1702.     if (append)
  1703.         fseek(g, 0L, SEEK_END);
  1704.     do
  1705.     {
  1706.         copyfilepos(f, g, packetlength, fp);    /* Copy key out */
  1707.         /* Copy any following signature or userid packets */
  1708.         for ( ; ; )
  1709.         {    fp = ftell(f);
  1710.             status = nextkeypacket(f, &ctb);
  1711.             packetlength = ftell(f) - fp;
  1712.             if (status < 0  ||  is_key_ctb(ctb))
  1713.                 break;
  1714.             if (ctb==CTB_USERID  ||  is_ctb_type(ctb,CTB_SKE_TYPE))
  1715.                 copyfilepos(f, g, packetlength, fp);
  1716.         }
  1717.     }
  1718.     while (whole_ring && status >= 0);
  1719.  
  1720.     fclose(f);
  1721.     fclose(g);
  1722.  
  1723.     if (transflag)
  1724.     {    armor_file (fname, transfile, transname);
  1725.         wipefile (fname);
  1726.         remove (fname);
  1727.     }
  1728.  
  1729.     fprintf (pgpout,PSTR("\nKey extracted to file '%s'.\n"), transflag?transfile:fname);
  1730.  
  1731.     return (0);    /* normal return */
  1732. }    /* extract_from_keyring */
  1733.  
  1734.  
  1735. /*======================================================================*/
  1736.  
  1737. int merge_key_to_ringfile(char *keyfile, char* ringfile, long fp,
  1738.                 int packetlength)
  1739. /* Copy the key data in keyfile into ringfile, replacing the data that
  1740.    is in ringfile starting at fp and for length packetlength.
  1741. */
  1742. {    FILE    *f, *g, *h;
  1743.  
  1744.     if (build_path(SCRATCH_KEYRING_PATH,SCRATCH_KEYRING_FILENAME,ringfile)<0)
  1745.         return(-1);        /* File path too long */
  1746.     remove(SCRATCH_KEYRING_PATH);
  1747.     /* open file f for reading, binary, as keyring file */
  1748. #ifdef VMS
  1749.     if ((f = fopen(ringfile,"rb","ctx=stm")) == NULL)
  1750. #else
  1751.     if ((f = fopen(ringfile,"rb")) == NULL)
  1752. #endif
  1753.         return(-1);
  1754.     /* open file g for writing, binary, as scratch keyring file */
  1755.     if ((g = fopen(SCRATCH_KEYRING_PATH,"wb")) == NULL)
  1756.     {    fclose(f);
  1757.         return(-1);
  1758.     }
  1759.     /* open file h for reading, binary, as key file to be inserted */
  1760. #ifdef VMS
  1761.     if ((h = fopen(keyfile,"rb","ctx=stm")) == NULL)
  1762. #else
  1763.     if ((h = fopen(keyfile,"rb")) == NULL)
  1764. #endif
  1765.     {    fclose(f);
  1766.         fclose(g);
  1767.         return(-1);
  1768.     }
  1769.     /* Copy pre-key keyring data from f to g */
  1770.     copyfile(f,g,fp);
  1771.     /* Copy temp key data from h to g */
  1772.     copyfile(h,g,-1L);
  1773.     /* Copy post-key keyring data from f to g */
  1774.     copyfilepos(f,g,-1L,fp+packetlength);
  1775.     fclose(f);
  1776.     fclose(g);
  1777.     fclose(h);
  1778.  
  1779.     backup_rename(SCRATCH_KEYRING_PATH,ringfile);
  1780.  
  1781.     return(0);    /* normal return */
  1782. }    /* merge_key_to_ringfile */
  1783.  
  1784. static int insert_userid(char *keyfile, byte *userid, long fpos)
  1785. {    /* insert userid and trust byte at position fpos in file keyfile */
  1786.     char *tmpf;
  1787.     FILE *f, *g;
  1788.  
  1789.     tmpf = tempfile(TMP_TMPDIR);
  1790.     if ((f = fopenbin(keyfile, "r")) == NULL)
  1791.         return(-1);
  1792.     if ((g = fopenbin(tmpf, "w")) == NULL)
  1793.     {    fclose(f);
  1794.         return(-1);
  1795.     }
  1796.     copyfile(f, g, fpos);
  1797.     putc(CTB_USERID, g);
  1798.     fwrite(userid, 1, userid[0]+1, g);
  1799.     write_trust(g, KC_LEGIT_COMPLETE);
  1800.     copyfile(f, g, -1L);
  1801.     fclose(f);
  1802.     fflush(g);
  1803.     if (ferror(g))
  1804.     {    fclose(g);
  1805.         return(-1);
  1806.     }
  1807.     fclose(g);
  1808.     return(savetempbak(tmpf, keyfile));
  1809. }
  1810.  
  1811. int dokeyedit(char *mcguffin, char *ringfile)
  1812. /*    Edit the userid and/or pass phrase for an RSA key pair, and
  1813.     put them back into the ring files.
  1814. */
  1815. {    unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION], d[MAX_UNIT_PRECISION],
  1816.          p[MAX_UNIT_PRECISION], q[MAX_UNIT_PRECISION], u[MAX_UNIT_PRECISION];
  1817.     char *fname, secring[MAX_PATH];
  1818.     FILE *f;
  1819.     word16 iv[4]; /* for IDEA CFB mode, to protect RSA secret key */
  1820.     byte userid[256];
  1821.     byte userid1[256];
  1822.     char passphrase[256];
  1823.     word32 tstamp; byte *timestamp = (byte *) &tstamp;    /* key certificate timestamp */
  1824.     byte keyID[KEYFRAGSIZE];
  1825.     boolean hidekey;    /* TRUE iff secret key is encrypted */
  1826.     boolean changed=FALSE, changeID=FALSE;
  1827.     byte ctb;
  1828.     int status;
  1829.     long fpp,fps,trust_pos;
  1830.     int pplength=0, pslength=0;
  1831.     byte ideakey[16];
  1832.     byte keyctrl;
  1833.  
  1834.     if (!ringfile || strlen(ringfile)==0 || !mcguffin || strlen(mcguffin)==0)
  1835.         return(-1);    /* Need ringfile name, user name */
  1836.  
  1837.     force_extension(ringfile,PGP_EXTENSION);
  1838.  
  1839.     strcpy((char *)userid, mcguffin);
  1840.     fprintf(pgpout,PSTR("\nEditing userid \"%s\" in key ring: '%s'.\n"),
  1841.         EXTERNAL((char *)userid),ringfile);
  1842.  
  1843.     if (!file_exists (ringfile))
  1844.     {    fprintf(pgpout,PSTR("\nCan't open public key ring file '%s'\n"),
  1845.             ringfile);
  1846.         return(-1);
  1847.     }
  1848.  
  1849.     status = getpublickey(TRUE, TRUE, ringfile, &fpp, &pplength, NULL,
  1850.                 timestamp, userid, n, e);
  1851.     if (status < 0)
  1852.     {    fprintf(pgpout,PSTR("\n\007Key not found in key ring '%s'.\n"),
  1853.             ringfile);
  1854.         return(-1);
  1855.     }
  1856.  
  1857.     /* Now add to pplength any following key control certificate */
  1858. #ifdef VMS
  1859.     if ((f = fopen(ringfile,"r+b","ctx=stm")) == NULL)
  1860. #else
  1861.     if ((f = fopen(ringfile,"r+b")) == NULL)
  1862. #endif
  1863.     {    fprintf(pgpout,PSTR("\n\007Can't open key ring file '%s'\n"),ringfile);
  1864.         return(-1);
  1865.     }
  1866.  
  1867.     fseek(f, fpp, SEEK_SET);
  1868.     if (is_compromised(f))
  1869.     {    fprintf(pgpout, PSTR("\n\007This key has been revoked by its owner.\n"));
  1870.         fclose(f);
  1871.         return(-1);
  1872.     }
  1873.     trust_pos = fpp+pplength;
  1874.     fseek(f, trust_pos, SEEK_SET);
  1875.     if (read_trust(f, &keyctrl) < 0)
  1876.         trust_pos = -1;        /* keyfile: no trust byte */
  1877.  
  1878.     extract_keyID(keyID, n);
  1879.  
  1880.     /* Now read private key, too */
  1881.     strcpy(secring, ringfile);
  1882.     strcpy(file_tail(secring), SECRET_KEYRING_FILENAME);
  1883.  
  1884.     if (!file_exists (secring))
  1885.     {    fprintf(pgpout,PSTR("\nCan't open secret key ring file '%s'\n"),
  1886.             secring);
  1887.         fclose(f);
  1888.         return(-1);
  1889.     }
  1890.  
  1891.     /* Get position of key in secret key file */
  1892.     strcpy((char *)userid1, mcguffin);
  1893.     (void)getpublickey(TRUE, FALSE, secring, &fps, &pslength, NULL,
  1894.         timestamp, userid1, n, e);
  1895.     /* This was done to get us fps and pslength */
  1896.     strcpy((char *)userid1, mcguffin);
  1897.     status = getsecretkey(TRUE, FALSE, secring, keyID, timestamp,
  1898.         passphrase, &hidekey, userid1, n, e, d, p, q, u);
  1899.  
  1900.     if (status < 0)        /* key not in secret keyring: edit owner trust */
  1901.     {    int i;
  1902.  
  1903.         fprintf(pgpout, PSTR("\nNo secret key available.  Editing public key trust parameter.\n"));
  1904.         if (trust_pos < 0)
  1905.         {    fprintf(pgpout,PSTR("\n\007File '%s' is not a public keyring.\n"), ringfile);
  1906.             fclose(f);
  1907.             return(-1);
  1908.         }
  1909.         show_key(f, fpp, SHOW_ALL);
  1910.  
  1911.         init_trust_lst();
  1912.         fprintf(pgpout, PSTR("Current trust for this key's owner is: %s\n"),
  1913.                 trust_lst[keyctrl & KC_OWNERTRUST_MASK]);
  1914.  
  1915.         PascalToC((char *)userid);    /* convert to C string for display */
  1916.         i = ask_owntrust((char *) userid, keyctrl);
  1917.         if (i == (keyctrl & KC_OWNERTRUST_MASK))
  1918.         {    fclose(f);
  1919.             return(0);    /* unchanged */
  1920.         }
  1921.  
  1922.         if (i < 0 || i > KC_OWNERTRUST_ALWAYS)
  1923.         {
  1924.             fclose(f);
  1925.             return(-1);
  1926.         }
  1927.         keyctrl = (keyctrl & ~KC_OWNERTRUST_MASK) | i;
  1928.  
  1929.         fseek(f, trust_pos, SEEK_SET);
  1930.         write_trust(f, keyctrl);
  1931.         fclose(f);
  1932.         fprintf (pgpout, PSTR("Public key ring updated.\n"));
  1933.         return(0);
  1934.     }
  1935.     if (trust_pos > 0 && (keyctrl & (KC_BUCKSTOP|KC_OWNERTRUST_MASK)) !=
  1936.             (KC_OWNERTRUST_ULTIMATE|KC_BUCKSTOP))
  1937.     {    /* key is in secret keyring but buckstop is not set */
  1938.         fprintf(pgpout, PSTR("\nUse this key as an ultimately-trusted introducer (y/N)? "), userid);
  1939.         if (getyesno('n'))
  1940.         {    fseek(f, trust_pos, SEEK_SET);
  1941.             keyctrl = KC_OWNERTRUST_ULTIMATE|KC_BUCKSTOP;
  1942.             write_trust(f, keyctrl);
  1943.         }
  1944.     }
  1945.  
  1946.     /* Show user her ID again to be clear */
  1947.     PascalToC((char *)userid);
  1948.     fprintf(pgpout,PSTR("\nCurrent user ID: %s"),EXTERNAL((char *)userid));
  1949.     CToPascal((char *)userid);
  1950.  
  1951.     fprintf(pgpout, PSTR("\nDo you want to change your user ID (y/N)? "));
  1952.     if (getyesno('n'))    /* user said yes */
  1953.     {    fprintf(pgpout,PSTR("\nEnter the new user ID: "));
  1954.         getstring((char *)userid,255,TRUE); /* echo keyboard input */
  1955.         if (userid[0] == '\0')
  1956.         {    fclose(f);
  1957.             return(-1);
  1958.         }
  1959.         INTERNAL((char *)userid);
  1960.         fprintf(pgpout, PSTR("\nMake this user ID the primary user ID for this key (y/N)? "));
  1961.         if (!getyesno('n'))
  1962.         {    /* possition file pointer at selected user id */
  1963.             int pktlen;
  1964.             long fpuser;
  1965.  
  1966.             strcpy((char *)userid1, mcguffin);
  1967.             if (getpubuserid(ringfile, fpp, userid1, &fpuser, &pktlen) < 0)
  1968.             {    fclose(f);
  1969.                 return(-1);
  1970.             }
  1971.             fseek(f, fpuser, SEEK_SET);
  1972.         }
  1973.         else    /* possition file pointer at key packet */
  1974.             fseek(f, fpp, SEEK_SET);
  1975.         nextkeypacket(f, &ctb);    /* skip userid or key packet */
  1976.         do    /* new user id will be inserted before next userid or key packet */
  1977.         {    fpp = ftell(f);
  1978.             if (nextkeypacket(f, &ctb) < 0)
  1979.                 break;
  1980.         } while (ctb != CTB_USERID && !is_key_ctb(ctb));
  1981.         CToPascal((char *)userid);        /* convert to length-prefixed string */
  1982.         changeID = TRUE;
  1983.         changed = TRUE;
  1984.     }
  1985.     fclose(f);
  1986.  
  1987.     fprintf (pgpout,PSTR("\nDo you want to change your pass phrase (y/N)? "));
  1988.     if (getyesno('n'))    /* user said yes */
  1989.     {    hidekey = (getideakey(passphrase, (char *) ideakey, 2) > 0);
  1990.         changed = TRUE;
  1991.     }
  1992.     else
  1993.     {    if (hidekey)
  1994.             hashpass( passphrase, strlen(passphrase), ideakey );
  1995.     }
  1996.  
  1997.     if (!changed)
  1998.     {    fprintf (pgpout, PSTR("(No changes will be made.)\n"));
  1999.         if (hidekey)
  2000.             burn((byteptr)passphrase);
  2001.         goto done;
  2002.     }
  2003.  
  2004.     /* init CFB IDEA key */
  2005.     if (hidekey)
  2006.     {    fill0(iv,8);
  2007.         initcfb_idea(iv,ideakey,FALSE);
  2008.         burn((byteptr)passphrase);    /* burn sensitive data on stack */
  2009.     }
  2010.  
  2011.     /* First write secret key data to a file */
  2012.     fname = tempfile(TMP_TMPDIR|TMP_WIPE);
  2013.     writekeyfile(fname,hidekey,timestamp,userid,n,e,d,p,q,u);
  2014.     if (merge_key_to_ringfile(fname,secring,fps,pslength) < 0)
  2015.     {    fprintf (pgpout, PSTR("\n\007Unable to update secret key ring.\n"));
  2016.         goto err;
  2017.     }
  2018.     fprintf (pgpout, PSTR("\nSecret key ring updated...\n"));
  2019.  
  2020.     /* Now write public key data to file */
  2021.     if (changeID)
  2022.     {
  2023.         if (insert_userid(ringfile, userid, fpp) < 0)
  2024.         {    fprintf (pgpout, PSTR("\n\007Unable to update public key ring.\n"));
  2025.             goto err;
  2026.         }
  2027.         fprintf (pgpout, PSTR("Public key ring updated.\n"));
  2028.     }
  2029.     else
  2030.         fprintf (pgpout, PSTR("(No need to update public key ring)\n"));
  2031.  
  2032.     if (hidekey)    /* done with IDEA to protect RSA secret key */
  2033.         close_idea();
  2034.  
  2035.     rmtemp(fname);
  2036.  
  2037. done:
  2038.     mp_burn(d);    /* burn sensitive data on stack    */
  2039.     mp_burn(p);    /*     "        "        "    "    "    */
  2040.     mp_burn(q);    /*    "        "        "    "    "    */
  2041.     mp_burn(u);    /*    "        "        "    "    "    */
  2042.     mp_burn(e);    /*    "        "        "    "    "    */
  2043.     mp_burn(n);    /*    "        "        "    "    "    */
  2044.     burn(iv);    /*    "        "        "    "    "    */
  2045.  
  2046.     return(0);    /* normal return */
  2047. err:
  2048.     mp_burn(d);    /* burn sensitive data on stack */
  2049.     mp_burn(p);    /*    "        "        "    "    "    */
  2050.     mp_burn(q);    /*    "        "        "    "    "    */
  2051.     mp_burn(u);    /*    "        "        "    "    "    */
  2052.     mp_burn(e);    /*    "        "        "    "    "    */
  2053.     mp_burn(n);    /*    "        "        "    "    "    */
  2054.     burn(iv);    /*    "        "        "    "    "    */
  2055.  
  2056.     rmtemp(fname);
  2057.  
  2058.     return(-1);    /* error return */
  2059.  
  2060. }    /* dokeyedit */
  2061.  
  2062.  
  2063. /*======================================================================*/
  2064.  
  2065.  
  2066.  
  2067. int dokeygen(char *numstr, char *numstr2)
  2068. /*    Do an RSA key pair generation, and write them out to the keyring files.
  2069.     numstr is a decimal string, the desired bitcount for the modulus n.
  2070.     numstr2 is a decimal string, the desired bitcount for the exponent e.
  2071. */
  2072. {    unit n[MAX_UNIT_PRECISION], e[MAX_UNIT_PRECISION], d[MAX_UNIT_PRECISION],
  2073.          p[MAX_UNIT_PRECISION], q[MAX_UNIT_PRECISION], u[MAX_UNIT_PRECISION];
  2074.     char *fname;
  2075.     char ringfile[MAX_PATH];
  2076.     word16 iv[4]; /* for IDEA CFB mode, to protect RSA secret key */
  2077.     byte userid[256];
  2078.     short keybits,ebits;
  2079.     word32 tstamp; byte *timestamp = (byte *) &tstamp;        /* key certificate timestamp */
  2080.     boolean hidekey;    /* TRUE iff secret key is encrypted */
  2081.     byte ideakey[16];
  2082.  
  2083.     if (!numstr || strlen(numstr)==0)
  2084.     {    fprintf(pgpout,PSTR("\nPick your RSA key size:\
  2085. \n    1)     384 bits- Casual grade, fast but less secure\
  2086. \n    2)     512 bits- Commercial grade, medium speed, good security\
  2087. \n    3)    1024 bits- Military grade, very slow, highest security\
  2088. \nChoose 1, 2, or 3, or enter desired number of bits: "));
  2089.         numstr = (char *)userid;    /* use userid buffer as scratchpad */
  2090.         getstring(numstr,5,TRUE);    /* echo keyboard */
  2091.     }
  2092.  
  2093.     keybits = 0;
  2094.     while ((*numstr>='0') && (*numstr<='9'))
  2095.         keybits = keybits*10 + (*numstr++ - '0');
  2096.  
  2097.     if (keybits==0)    /* user entered null response */
  2098.         return(-1);    /* error return */
  2099.  
  2100.     /* Standard default key sizes: */
  2101.     if (keybits==1) keybits=384;    /* Casual grade */
  2102.     if (keybits==2) keybits=512;    /* Commercial grade */
  2103.     if (keybits==3) keybits=1024;    /* Military grade */
  2104.  
  2105. #ifndef DEBUG
  2106.     /* minimum RSA keysize: */
  2107.     if (keybits<384) keybits=384;
  2108. #endif
  2109.  
  2110. #ifdef MERRITT    
  2111. /*    If we use Merritt's modmult algorithm, the primes p and q's 
  2112.     bit length should not be an exact multiple of UNITSIZE, 
  2113.     because Merritt's modmult algorithm performs slowest in that 
  2114.     case, wasting an extra unit of precision for overflow.
  2115. */
  2116.     if ((keybits % (2*UNITSIZE))==0)
  2117.         keybits -= 2;    /* make each prime one bit shorter. */
  2118. #endif    /* MERRITT */
  2119.  
  2120.     ebits = 0;    /* number of bits in e */
  2121.     while ((*numstr2>='0') && (*numstr2<='9')) 
  2122.         ebits = ebits*10 + (*numstr2++ - '0');
  2123.  
  2124.     fprintf(pgpout,PSTR("\nGenerating an RSA key with a %d-bit modulus... "),keybits);
  2125.  
  2126.     fprintf(pgpout,
  2127. PSTR("\nYou need a user ID for your public key.  The desired form for this\n\
  2128. user ID is your name, followed by your E-mail address enclosed in\n\
  2129. <angle brackets>, if you have an E-mail address.\n\
  2130. For example:  John Q. Smith <12345.6789@compuserve.com>\n"));
  2131.     fprintf(pgpout,PSTR("\nEnter a user ID for your public key: \n"));
  2132.     getstring((char *)userid,255,TRUE);    /* echo keyboard input */
  2133.     if (userid[0]=='\0')    /* user entered null response */
  2134.         return(-1);    /* error return */
  2135.     INTERNAL((char *)userid);
  2136.     CToPascal((char *)userid);    /* convert to length-prefixed string */
  2137.  
  2138.     {    char passphrase[256];
  2139.         fprintf(pgpout,
  2140. PSTR("\nYou need a pass phrase to protect your RSA secret key.\n\
  2141. Your pass phrase can be any sentence or phrase and may have many\n\
  2142. words, spaces, punctuation, or any other printable characters. "));
  2143.         hidekey = (getideakey(passphrase, (char *) ideakey, 2) > 0);
  2144.         /* init CFB IDEA key */
  2145.         if (hidekey)
  2146.         {    fill0(iv,8);
  2147.             initcfb_idea(iv,ideakey,FALSE);
  2148.             burn((byteptr)passphrase);    /* burn sensitive data on stack */
  2149.         }
  2150.     }
  2151.  
  2152.     fprintf(pgpout,PSTR("\nNote that key generation is a VERY lengthy process.\n"));
  2153.  
  2154.     if (rsa_keygen(n,e,d,p,q,u,keybits,ebits) < 0)
  2155.     {    fprintf(pgpout,PSTR("\n\007Keygen failed!\n"));
  2156.         return(-1);    /* error return */
  2157.     }
  2158.  
  2159.     if (verbose)
  2160.     {
  2161.         fprintf(pgpout,PSTR("Key ID %s\n"), key2IDstring(n));
  2162.  
  2163.         mp_display(" modulus n = ",n);
  2164.         mp_display("exponent e = ",e);
  2165.  
  2166.         mp_display("exponent d = ",d);
  2167.         mp_display("   prime p = ",p);
  2168.         mp_display("   prime q = ",q);
  2169.         mp_display(" inverse u = ",u);
  2170.     }
  2171.  
  2172.     get_timestamp(timestamp);    /* Timestamp when key was generated */
  2173.  
  2174.     fputc('\007',pgpout);  /* sound the bell when done with lengthy process */
  2175.     fputc('\n',pgpout);
  2176.  
  2177.     /* First, write out the secret key... */
  2178.     fname = tempfile(TMP_TMPDIR|TMP_WIPE);
  2179.     writekeyfile(fname,hidekey,timestamp,userid,n,e,d,p,q,u); 
  2180.     buildfilename(ringfile,SECRET_KEYRING_FILENAME);
  2181.     if (file_exists(ringfile))
  2182.     {    merge_key_to_ringfile(fname,ringfile,0L,0);
  2183.         rmtemp(fname);
  2184.     }
  2185.     else
  2186.         savetemp(fname, ringfile);
  2187.  
  2188.     /* Second, write out the public key... */
  2189.     fname = tempfile(TMP_TMPDIR|TMP_WIPE);
  2190.     writekeyfile(fname,FALSE,timestamp,userid,n,e,NULL,NULL,NULL,NULL);
  2191.     buildfilename(ringfile,PUBLIC_KEYRING_FILENAME);
  2192.     if (file_exists(ringfile))
  2193.     {    merge_key_to_ringfile(fname,ringfile,0L,0);
  2194.         rmtemp(fname);
  2195.     }
  2196.     else
  2197.         savetemp(fname, ringfile);
  2198.     
  2199.     if (hidekey)    /* done with IDEA to protect RSA secret key */
  2200.         close_idea();
  2201.  
  2202.     mp_burn(d);    /* burn sensitive data on stack */
  2203.     mp_burn(p);    /* burn sensitive data on stack */
  2204.     mp_burn(q);    /* burn sensitive data on stack */
  2205.     mp_burn(u);    /* burn sensitive data on stack */
  2206.     mp_burn(e);    /* burn sensitive data on stack */
  2207.     mp_burn(n);    /* burn sensitive data on stack */
  2208.     burn(iv);    /* burn sensitive data on stack */
  2209.  
  2210.     fprintf(pgpout,PSTR("\007Key generation completed.\n"));
  2211.  
  2212.     /*    Force initialization of cryptographically strong pseudorandom
  2213.         number generator seed file for later use...
  2214.     */
  2215.     strong_pseudorandom((byte *) iv,1);
  2216.  
  2217.     return(0);    /* normal return */
  2218. }    /* dokeygen */
  2219.  
  2220.